home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / networke / xnetmine.tgz / XNetMine / XNetMine.c < prev   
C/C++ Source or Header  |  1994-09-26  |  50KB  |  1,384 lines
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <X11/X.h>
  4. #include <X11/Xlib.h>
  5. #include <X11/Xutil.h>
  6. #include <X11/Xatom.h>
  7. #include <X11/Xos.h>
  8. #include <X11/Xresource.h>
  9. /*** Sockets include *****/
  10. #include <errno.h>      /* obligatory includes */
  11. #include <signal.h> 
  12. #include <sys/types.h>
  13. #include <fcntl.h>
  14. #include <unistd.h> 
  15. #include <sys/socket.h>
  16. #include <sys/time.h> 
  17. #include <sys/wait.h> 
  18. #include <netinet/in.h>
  19. #include <netdb.h>
  20.  
  21.  
  22.  
  23. #define X_MAX    31        /* wert+1 = maximale anzahl steine in x            */ 
  24. #define Y_MAX    17        /* dto. nur fuer y                                 */
  25. #define BOMB_MAX 80        /* wieviele Steine maximal auf dem Spielfeld sind */
  26.  
  27. #define LEER      0            
  28. #define SHOW      18
  29. #define LOCK      20
  30. #define HIDE      17
  31. #define NIX       21
  32. #define BOMB      19
  33. #define EXBOMB    22
  34.  
  35. #define max_msg   4 
  36. #define SWIDTH    20
  37. #define SHEIGHT   20
  38. #define bigx      20
  39. #define bigy      20
  40. #define BWIDTH    14
  41. #define XOFFSET   10
  42. #define YOFFSET   60
  43. #define BHEIGHT   14
  44.  
  45. struct verbindungen {                                        /* struktur der verbindungsliste     */
  46.                           int    kanal_nummer;                 /* Kanal-nummer                      */
  47.                           struct verbindungen *nextptr;          /* zeiger auf naechstes element      */
  48.                            char Was;                    /* ='W' write to server    ='R' read to server */
  49.                        };
  50.  
  51. short int Feld_Intern[X_MAX+X_MAX*Y_MAX+10];
  52. short int Feld_Visible[X_MAX+X_MAX*Y_MAX+10];
  53. short int Feld_Backup[X_MAX+X_MAX*Y_MAX+10];
  54.  
  55. struct AnfragePaket
  56.  {
  57.      short int Feld_Visible[X_MAX+X_MAX*Y_MAX+10];
  58.      short int Feld_Intern[X_MAX+X_MAX*Y_MAX+10];
  59.      char UserName[100];
  60.      char Was;                    /* ='W' write to server    ='R' read to server */
  61.  };
  62.  
  63. int t,i,z,u,v,w,x,y,xx,yy,weiter_msg;
  64. int spiel_laeuft,err;
  65. Display *display;
  66. Window  window;
  67. struct verbindungen *next;
  68. char fontname[80] = "8x13bold";
  69. char *Display_name = NULL; 
  70. unsigned long bg; 
  71. int sock_server,sock_client,screen;
  72. int s1,s2,max,HighScore;
  73. Window  hswindow = 0;
  74. XEvent event;
  75. XSizeHints hint;
  76. GC gc,hsgc;
  77. GC highlightgc;
  78. XFontStruct *xfontinfo;
  79. int height;
  80. int highest_kanal_number ;
  81. int width;
  82. int Server,Client;
  83. char msg[max_msg+5][120];
  84. char ServerName[200],User[200],Port[200],text[100],winner[100];
  85. KeySym  key;
  86. Colormap cmap;
  87. XColor exact_def;
  88. unsigned long foreground, background,patbg,patfg,b1,b2,b3,b4,b5,b6,b7,b8,gray,white,black;
  89. int depth;
  90. Pixmap graypix;
  91. Pixmap minepix;
  92. Pixmap minepix_a;   
  93. Pixmap coveredpix;
  94. Pixmap smileypix;
  95. Pixmap copyrightpix;
  96. Pixmap netpix;
  97. Pixmap newpix;
  98. Pixmap lockpix;
  99.  
  100. char lock_bits[] = {
  101.  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0xe0, 0x3f, 0x00,
  102.   0xe0, 0x3f, 0x00, 0xc0, 0x1f, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x00,
  103.   0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00,
  104.   0x00, 0x02, 0x00, 0x00, 0x07, 0x00, 0xc0, 0x1f, 0x00, 0xe0, 0x3f, 0x00,
  105.   0xe0, 0x3f, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  106.   };
  107.  
  108.  
  109. char new_bits[] = {
  110.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff,
  111.   0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
  112.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff,
  113.   0xff, 0xff, 0xff, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f,
  114.   0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xcf, 0xff, 0xff, 0xff,
  115.   0xff, 0xff, 0xcf, 0x0f, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x0f,
  116.   0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x0f, 0xcf, 0xff, 0xff, 0xff,
  117.   0xff, 0xff, 0xcf, 0x0f, 0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f,
  118.   0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f, 0xcf, 0x03, 0x00, 0x00,
  119.   0x00, 0x80, 0xcf, 0x0f, 0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f,
  120.   0xcf, 0xc3, 0xf0, 0xbf, 0x3b, 0x87, 0xcf, 0x0f, 0xcf, 0x83, 0x21, 0x21,
  121.   0x11, 0x82, 0xcf, 0x0f, 0xcf, 0x83, 0x21, 0x01, 0x33, 0x82, 0xcf, 0x0f,
  122.   0xcf, 0x83, 0x22, 0x11, 0x22, 0x81, 0xcf, 0x0f, 0xcf, 0x83, 0x24, 0x1f,
  123.   0x76, 0x81, 0xcf, 0x0f, 0xcf, 0x83, 0x24, 0x11, 0x54, 0x81, 0xcf, 0x0f,
  124.   0xcf, 0x83, 0x28, 0x01, 0xcc, 0x80, 0xcf, 0x0f, 0xcf, 0x83, 0x30, 0x21,
  125.   0x88, 0x80, 0xcf, 0x0f, 0xcf, 0xc3, 0xa1, 0x3f, 0x88, 0x80, 0xcf, 0x0f,
  126.   0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f, 0xcf, 0x03, 0x00, 0x00,
  127.   0x00, 0x80, 0xcf, 0x0f, 0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f,
  128.   0xcf, 0x03, 0x00, 0x00, 0x00, 0x80, 0xcf, 0x0f, 0xcf, 0xff, 0xff, 0xff,
  129.   0xff, 0xff, 0xcf, 0x0f, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x0f,
  130.   0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x0f, 0xcf, 0xff, 0xff, 0xff,
  131.   0xff, 0xff, 0xcf, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f,
  132.   0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xff,
  133.   0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
  134.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff,
  135.   0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
  136.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, };
  137.  
  138. static unsigned char net_bits[] = {
  139.  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x22, 0x22, 0x22, 0x22,
  140.   0x22, 0x22, 0x22, 0x02, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04,
  141.   0x88, 0x88, 0x88, 0x08, 0x88, 0x88, 0x88, 0x08, 0x44, 0x44, 0x44, 0x44,
  142.   0x44, 0x44, 0x44, 0x04, 0x22, 0x22, 0x22, 0x22, 0x02, 0x22, 0x22, 0x02,
  143.   0x11, 0x11, 0x01, 0x11, 0x11, 0x10, 0x11, 0x01, 0x22, 0x02, 0x22, 0x22,
  144.   0x22, 0x02, 0x22, 0x02, 0x44, 0x04, 0x40, 0x40, 0x40, 0x44, 0x44, 0x04,
  145.   0x80, 0x00, 0x80, 0x00, 0x08, 0x80, 0x88, 0x08, 0x44, 0x00, 0x00, 0x00,
  146.   0x00, 0x00, 0x44, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02,
  147.   0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x11, 0x01, 0x22, 0x02, 0x1e, 0xe7,
  148.   0xf7, 0x07, 0x22, 0x02, 0x44, 0x00, 0x33, 0x42, 0x92, 0x04, 0x44, 0x04,
  149.   0x88, 0x00, 0x21, 0x42, 0x82, 0x00, 0x88, 0x08, 0x44, 0x80, 0x40, 0x42,
  150.   0x82, 0x00, 0x44, 0x04, 0x22, 0x80, 0x40, 0x42, 0x82, 0x00, 0x22, 0x02,
  151.   0x11, 0x80, 0x40, 0x42, 0x82, 0x00, 0x11, 0x01, 0x00, 0x02, 0x21, 0x42,
  152.   0x82, 0x00, 0x20, 0x02, 0x44, 0x00, 0x33, 0x66, 0x82, 0x00, 0x44, 0x04,
  153.   0x88, 0x00, 0x1e, 0x3c, 0xc7, 0x01, 0x88, 0x08, 0x44, 0x04, 0x18, 0x00,
  154.   0x00, 0x00, 0x44, 0x04, 0x22, 0x00, 0x60, 0x00, 0x00, 0x00, 0x22, 0x02,
  155.   0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x01, 0x22, 0x02, 0x00, 0x00,
  156.   0x00, 0x20, 0x02, 0x02, 0x44, 0x04, 0x00, 0x00, 0x00, 0x40, 0x44, 0x04,
  157.   0x88, 0x00, 0x00, 0x00, 0x00, 0x80, 0x88, 0x08, 0x44, 0x44, 0x00, 0x40,
  158.   0x00, 0x40, 0x44, 0x04, 0x22, 0x22, 0x20, 0x20, 0x22, 0x22, 0x22, 0x02,
  159.   0x11, 0x01, 0x01, 0x11, 0x11, 0x10, 0x11, 0x01, 0x22, 0x22, 0x22, 0x22,
  160.   0x22, 0x22, 0x22, 0x02, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04,
  161.   0x88, 0x08, 0x88, 0x88, 0x80, 0x88, 0x88, 0x08, 0x44, 0x44, 0x44, 0x44,
  162.   0x44, 0x44, 0x44, 0x04, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x02,
  163.   0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x22, 0x22, 0x22, 0x22,
  164.   0x22, 0x22, 0x22, 0x02, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x00,
  165.   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x08, };
  166.  
  167.  
  168. char copyright_bits[] = {
  169.   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  170.   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  171.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x10, 0x10, 0x10, 0x10,
  172.   0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
  173.   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0xff, 0xff, 0x7f, 0xfb,
  174.   0xf8, 0xff, 0xff, 0x0f, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01,
  175.   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
  176.   0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0x7e, 0x62, 0x40, 0xff, 0xff, 0x0f,
  177.   0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00,
  178.   0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,
  179.   0xff, 0xff, 0x1a, 0x01, 0x00, 0xfa, 0xff, 0x0f, 0x01, 0x01, 0x01, 0xe0,
  180.   0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0xb0, 0x03, 0x01, 0x01, 0x01,
  181.   0x01, 0x01, 0x00, 0x18, 0x02, 0x00, 0x01, 0x01, 0xff, 0xff, 0x03, 0x08,
  182.   0x00, 0xf8, 0xff, 0x0f, 0x10, 0x10, 0x00, 0x08, 0x00, 0x10, 0x10, 0x00,
  183.   0x10, 0x10, 0x10, 0x08, 0x02, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x18,
  184.   0x02, 0x10, 0x10, 0x00, 0xff, 0xff, 0x05, 0x30, 0x03, 0xff, 0xff, 0x0f,
  185.   0x01, 0x01, 0x01, 0xe0, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
  186.   0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01,
  187.   0xff, 0xff, 0x35, 0x01, 0x00, 0xf9, 0xff, 0x0f, 0x10, 0x10, 0x10, 0x00,
  188.   0x00, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,
  189.   0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0xff, 0xff, 0xff, 0xff,
  190.   0xff, 0xff, 0xff, 0x0f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  191.   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  192.   0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f,
  193.   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x10,
  194.   0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
  195.   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, };
  196.  
  197. char covered_bits[] = {
  198.    0x00, 0x00, 0x08, 0x00, 0x00, 0x0c, 0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e,
  199.    0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e, 0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e,
  200.    0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e, 0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e,
  201.    0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e, 0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e,
  202.    0x54, 0x55, 0x0d, 0xa8, 0xaa, 0x0e, 0xfe, 0xff, 0x0f, 0xff, 0xff, 0x0f};
  203.  
  204. char gray_bits[] = {
  205.    0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a,
  206.    0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a,
  207.    0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a,
  208.    0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a,
  209.    0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x0a};
  210.  
  211. char mine_bits[] = {
  212.    0xff, 0xff, 0x0f, 0x01, 0x00, 0x08, 0x01, 0x02, 0x08, 0x01, 0x02, 0x08,
  213.    0x91, 0x4f, 0x08, 0xe1, 0x3f, 0x08, 0xe1, 0x3f, 0x08, 0x71, 0x7e, 0x08,
  214.    0x71, 0x7e, 0x08, 0xfd, 0xff, 0x09, 0xf1, 0x7f, 0x08, 0xf1, 0x7f, 0x08,
  215.    0xe1, 0x3f, 0x08, 0xe1, 0x3f, 0x08, 0x91, 0x4f, 0x08, 0x01, 0x02, 0x08,
  216.    0x01, 0x02, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0xff, 0xff, 0x0f};
  217.  
  218. char smiley_bits[] = {
  219.    0xff, 0xff, 0x0f, 0x01, 0x00, 0x0c, 0x81, 0x0f, 0x0c, 0x61, 0x30, 0x0c,
  220.    0x11, 0x40, 0x0c, 0x09, 0x80, 0x0c, 0x09, 0x80, 0x0c, 0x45, 0x10, 0x0d,
  221.    0x05, 0x00, 0x0d, 0x05, 0x00, 0x0d, 0x05, 0x00, 0x0d, 0x25, 0x20, 0x0d,
  222.    0xc9, 0x98, 0x0c, 0x09, 0x87, 0x0c, 0x11, 0x40, 0x0c, 0x61, 0x30, 0x0c,
  223.    0x81, 0x0f, 0x0c, 0x01, 0x00, 0x0c, 0xff, 0xff, 0x0f, 0xff, 0xff, 0x0f};
  224.  
  225. void draw_screen();
  226. void male_gitter();
  227. void draw_item();
  228. unsigned long getcolor();
  229.  
  230. /***********************************/
  231.  
  232. int reads(socket,ptr,size)
  233. int socket;
  234. char *ptr;
  235. int size;
  236. { int s,t,r;
  237.   r=0; t=0; s=0;
  238.  for (;1==1;)
  239.  {
  240.   t++;
  241.   if (t>(size+3)) return(r);
  242.   s=read(socket,ptr,size-r); 
  243.   ptr=ptr+s;
  244.   r=r+s;
  245.   if (r==-1) { return(0); }
  246.   if (r==size) return(size);
  247.  }
  248. }
  249.  
  250.  
  251.  int call_socket(hostname, portnum)
  252.  
  253.   char *hostname;
  254.   long portnum;
  255.   { struct sockaddr_in sa;
  256.     struct hostent     *hp;
  257.     int a, s;
  258.  
  259.     if ((hp= gethostbyname(hostname)) == NULL) { /* do we know the host's */
  260.       errno= ECONNREFUSED;                       /* address? */
  261.       return(-1);                                /* no */
  262.     }
  263.  
  264.     bzero(&sa,sizeof(sa));
  265.     bcopy(hp->h_addr,(char *)&sa.sin_addr,hp->h_length); /* set address */
  266.     sa.sin_family= hp->h_addrtype;
  267.     sa.sin_port= htons((u_short)portnum);
  268.     if ((s= socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)   /* get socket */
  269.       return(-1);
  270.     if (connect(s,(struct sockaddr *)&sa,sizeof sa) < 0)                    /* connect */
  271.       return(-1);
  272.     return(s);
  273.   }
  274.  
  275. int establish(portnum)                                         /* funktion stellt einen socket zur */
  276.   u_short portnum;                                             /* zur verfuegung                   */
  277.  
  278.  {  char   myname[100];                                        /* diverse variablen                */
  279.     int    s;
  280.     struct sockaddr_in sa;
  281.     struct hostent *hp;
  282.  
  283.     bzero(&sa,sizeof(struct sockaddr_in));                     /* strukutr saubermachen           */
  284.     gethostname(myname,99);                                    /* unserer eigener hostname        */
  285.     hp= gethostbyname(myname);                                 /* ... infos ueber uns bekommen    */
  286.     if (hp == NULL)                                            /* gib es uns wirklich ?           */
  287.        {perror("Keine Hostadresse gefunden"); exit(-1); };     /* nein, scream and die ....       */
  288.     sa.sin_family= hp->h_addrtype;                             /* unsere host addresse            */
  289.     sa.sin_port= htons(portnum);                               /* unsere port nummer              */
  290.     if ((s= socket(AF_INET,SOCK_STREAM,0)) < 0)                /* und einen socket machen         */
  291.        {perror("Socket not installed"); exit(-1);};      /* kein socket => scream and die   */
  292.     if (bind(s,(struct sockaddr *) &sa,sizeof sa) < 0)         /* adresse dem socket mitteilen    */
  293.      { printf("\n XNetBomb-Server is already running !\n"); exit(-1);};   /* binde addresse zum socket       */
  294.     listen(s, 5 );                                             /* warteschlagne = 5 plaetze       */
  295.     return(s);                                                 /* und unseren socket zurueckgeben */
  296.  }
  297.  
  298.  
  299. alte_verbindung_loeschen(verbindung_next) /* loescht einen Kanal aus der Verbindungs-liste */
  300. struct verbindungen *verbindung_next;
  301. {
  302.  
  303. verbindung_next->Was=9;
  304. return;
  305. fflush(stdout);
  306.   if (verbindung_next==next)                                   /* sind wir erstes element ?       */
  307.      {                                                         /* ja,wir sind erstes element      */
  308.        next=verbindung_next->nextptr;
  309.        free(verbindung_next);
  310.      }
  311.    else                                                        /* nein, wir sind nicht erstes element */
  312.      { struct verbindungen *Ptr;
  313.        for (Ptr=next;Ptr!=NULL;) 
  314.        { if (Ptr->nextptr==verbindung_next)
  315.          {
  316.            Ptr->nextptr=verbindung_next->nextptr;
  317.            free(verbindung_next);
  318.           return;
  319.          }
  320.            Ptr=Ptr->nextptr;
  321.        }
  322.      }
  323. }
  324.  
  325.  
  326.  
  327. void Sende_to_Client()
  328. {          long res,max,t,err,size;
  329.            struct verbindungen *verbindung_next;
  330.            struct timeval timeout;
  331.            fd_set writefds;
  332.            struct AnfragePaket Anfrage;
  333.            Anfrage.Was=0;
  334.            strcpy( Anfrage.UserName,"SERVER");
  335.            max=X_MAX*Y_MAX+6; 
  336.            timeout.tv_sec=0;
  337.            timeout.tv_usec=900;
  338.            for (t=0;t<=max;t++)
  339.            {
  340.              Anfrage.Feld_Visible[t]=Feld_Visible[t];
  341.              Anfrage.Feld_Intern[t]=Feld_Intern[t];
  342.              if (Anfrage.Feld_Intern[t]==EXBOMB) Anfrage.Feld_Intern[t]=BOMB;
  343.            }
  344.            verbindung_next=next;                                            /* listenstart setzen                       */
  345.            for (;(verbindung_next!=NULL)&&(next!=NULL);)                    /* und bis zum letzten element machen ...   */
  346.             {
  347.               if (verbindung_next->Was=='R')
  348.               {
  349.                 size=sizeof(struct AnfragePaket);
  350.                 FD_ZERO(&writefds);
  351.                 FD_SET(verbindung_next->kanal_nummer,&writefds);
  352.                 err=0;
  353.                 res = select(verbindung_next->kanal_nummer+10,0,&writefds,0,&timeout);          
  354.                 if (res==1) { err=write(verbindung_next->kanal_nummer,&Anfrage,size); } 
  355.                 if (err!=size) {KillKanal(verbindung_next); }
  356.                 verbindung_next=verbindung_next->nextptr; 
  357.  
  358.               } else { verbindung_next=verbindung_next->nextptr; }
  359.             }   
  360. }
  361.  
  362. void neue_verbindung_einfuegen(wert,kanal_nummer)                  /* fuegt ein Kanal in die Verbindungsliste ein */
  363. char wert;
  364. int kanal_nummer;
  365. {
  366.   struct verbindungen *Ptr;
  367.   Ptr=(struct verbindungen *)malloc(sizeof(struct verbindungen));
  368.   if (Ptr==NULL) { printf("\n Error, no memory "); exit(-1); }
  369.   Ptr->kanal_nummer=kanal_nummer;
  370.    Ptr->nextptr=next;
  371.   Ptr->Was=wert;
  372.  
  373.   next=Ptr;
  374. }
  375.  
  376.  
  377. KillKanal(Ptr)
  378.  struct verbindungen *Ptr;
  379. { 
  380.  close ((int) Ptr->kanal_nummer);
  381.  
  382.  alte_verbindung_loeschen(Ptr);
  383. }
  384.  
  385. void Play_Server_Game()
  386. {
  387.   if (XPending(display))      
  388.   {
  389.    getXevent();    /* bearbeite event */
  390.   }
  391. }
  392.  
  393. void other_player_win(a)
  394. int a;
  395. {
  396. if (a==0)
  397. { /* client zeigt an */
  398.   spiel_laeuft=0;
  399.   strcpy(text,"Another Player win the game. Serverplayer will restart the game now.");
  400.   XSetForeground(display, gc, getcolor("gray",foreground));
  401.   XFillRectangle(display,window,gc,4,385,625,400);
  402.   strcpy(winner,text);
  403.   XSetForeground(display, gc, getcolor("blue",foreground));
  404.   XDrawString(display,window,gc,10,395 ,text,strlen(text));
  405. } else
  406. { /* Server zeigt an */
  407.   spiel_laeuft=0;
  408.   strcpy(text,"Another Player win the game. Please RESTART NOW the game.");
  409.   strcpy(winner,text);
  410.   XSetForeground(display, gc, getcolor("gray",foreground));
  411.   XFillRectangle(display,window,gc,4,385,625,400);
  412.   XSetForeground(display, gc, getcolor("blue",foreground));
  413.   XDrawString(display,window,gc,10,395 ,text,strlen(text));
  414.   Feld_Visible[X_MAX*Y_MAX+3]=77;
  415.   if (Server==1) Sende_to_Client();                     
  416. }
  417. }
  418.  
  419. int get_connection(s)                                       /* warte auf eine verbindungsversuch und verwalte die */
  420. int s;                                                      /* restlichen Lese/schreibaufforderungen ....         */
  421.  {
  422.     struct verbindungen *verbindung_next;
  423.     struct verbindungen *verbindung_neu;
  424.     struct sockaddr_in isa;                                   /* addresse des sockets                               */
  425.     char *buffer[10];
  426.     int size,i,err,change;                                    /* i=groesse der adresse                              */
  427.     int res,t,new_socket;                                     /* new_socket = socket of connection                  */
  428.     fd_set readfds;
  429.     fd_set writefds;
  430.     int nfds,okk;
  431.     struct timeval timeout;
  432.     FD_ZERO(&readfds);
  433.     change=1;
  434.     i = sizeof(isa);                                                     /* socket addresse finden                            */
  435.     getsockname(s,(struct sockaddr *) &isa,&i);                          /*                                                   */
  436.     while (1==1)              /* endlos machen */
  437.      {
  438.       Play_Server_Game();
  439.       timeout.tv_sec=0;
  440.       timeout.tv_usec=500;
  441.       FD_SET(s ,&readfds );
  442.       res=select(highest_kanal_number+10,&readfds,0,0,&timeout);               /* warte auf connect bzw. 100usec                    */
  443.       if ((FD_ISSET(s ,&readfds)) && (res>0))                                             /* war da ein connect ?                              */
  444.        {                                                                  /* ok, hier haben wir einen neuen requester          */
  445.         i = sizeof(isa);                                                     /* socket addresse finden                            */
  446.         getsockname(s,(struct sockaddr *) &isa,&i);                      
  447.         new_socket =accept(s ,(struct sockaddr *) &isa ,&i );           /* neuer socket in die liste aufnehmen               */
  448.         if (new_socket>=highest_kanal_number) {highest_kanal_number=new_socket+10;};  /* gleiche obergrenze fuer fd-files an     */
  449.         if (new_socket==-1) { exit(-1); }  
  450.         if (new_socket != -1) 
  451.          {  
  452.           struct AnfragePaket Anfrage;
  453.           size=sizeof(struct AnfragePaket);
  454.           FD_ZERO(&readfds);
  455.           FD_SET(new_socket ,&readfds );
  456.           timeout.tv_sec=10;
  457.           err=0;
  458.           timeout.tv_usec=900;
  459.           res = select(new_socket+3, &readfds, 0, 0, &timeout);
  460.           if (res==1) { err=reads(new_socket,&Anfrage,size); }
  461.           if (err==size) 
  462.            {
  463.             if (Anfrage.Was=='W') neue_verbindung_einfuegen('W',new_socket);
  464.             if (Anfrage.Was=='R') neue_verbindung_einfuegen('R',new_socket);  
  465.             Sende_to_Client();
  466.            }
  467.          }   
  468.        } 
  469.       verbindung_next=next;
  470.       FD_ZERO(&readfds);                                                              
  471.       timeout.tv_sec=0;                                                               
  472.       timeout.tv_usec=500;                                                            
  473.       okk=0; 
  474.       while (verbindung_next!=NULL)                                                    
  475.        {
  476.         if (verbindung_next->Was=='W') { okk=1; FD_SET(verbindung_next->kanal_nummer,&readfds); }  
  477.         verbindung_next=verbindung_next->nextptr;                                 
  478.        }
  479.       res=-1;
  480.       if (okk==1) 
  481.        {
  482.          res = select(highest_kanal_number, &readfds, 0, 0, &timeout);
  483.         }                 
  484.       if (res)                                                                 
  485.        {
  486.        verbindung_next=next;                                        
  487.         while ((verbindung_next!=NULL)&&(next!=NULL))                   
  488.          {
  489.           if (FD_ISSET(verbindung_next->kanal_nummer,&readfds))                  
  490.            { 
  491.             struct AnfragePaket Anfrage;
  492.             size=sizeof(struct AnfragePaket);
  493.             err=reads(verbindung_next->kanal_nummer,&Anfrage,size);
  494.             if (err!=size) { KillKanal(verbindung_next); }
  495.             if (err==size)
  496.              {
  497.                long max,t;
  498.                 max=X_MAX*Y_MAX; 
  499.      
  500.               if (Anfrage.Feld_Visible[max+3]==77)
  501.                 {
  502.                  spiel_laeuft=0;
  503.                  other_player_win(1);                        
  504.                 } 
  505.        
  506.               for (t=0;t<=max;t++)
  507.                 {
  508.                  if ((Anfrage.Feld_Visible[t]==SHOW) && (Feld_Visible[t]==HIDE))
  509.                   { 
  510.                    Feld_Visible[t]=SHOW; 
  511.                    change=1;
  512.                   }
  513.                 } 
  514.               
  515.              } 
  516.            } 
  517.           if (verbindung_next!=NULL) verbindung_next=verbindung_next->nextptr;
  518.          } 
  519.        } 
  520.        if (change==1) 
  521.         { 
  522.          Sende_to_Client();
  523.          for (y=1;(y<Y_MAX);y++)
  524.           {                    
  525.            for (x=1;x<X_MAX;x++)   
  526.             {
  527.              if (Feld_Visible[x+y*X_MAX]!=Feld_Backup[x+y*X_MAX])
  528.               {
  529.                draw_item(x,y);
  530.               }
  531.             } 
  532.           }                   
  533.          male_gitter();  
  534.         }  
  535.        change=0;
  536.      } 
  537. } 
  538.  
  539.  
  540.  
  541. unsigned long getcolor(s,monocolor)
  542.     char *s;
  543.     unsigned long monocolor;
  544. {
  545.     if(depth != 1)
  546.     {
  547.         XParseColor(display,cmap,s,&exact_def);
  548.         XAllocColor(display,cmap,&exact_def);
  549.         return exact_def.pixel;
  550.     }
  551.     else
  552.     {
  553.         return monocolor;
  554.     }
  555. }
  556.  
  557. void spielfeld_init()
  558. {
  559.  
  560. short int zufall_x,zufall_y; 
  561. int x,y,xx,yy;
  562. spiel_laeuft=1;
  563.  
  564. /* Init des Spielfeldes */
  565.  
  566. for (y=0;y<=Y_MAX;y++)
  567. {
  568.  for (x=0;x<=X_MAX;x++)
  569.  {
  570.   Feld_Intern [x+y*X_MAX]=0;
  571.   Feld_Visible[x+y*X_MAX]=HIDE;
  572.   Feld_Backup[x+y*X_MAX]=NIX;
  573.  }
  574. }
  575.  
  576.   Feld_Intern [Y_MAX*X_MAX+3]=0;
  577.   Feld_Visible[Y_MAX*X_MAX+3]=HIDE;
  578.   Feld_Backup [Y_MAX*X_MAX+3]=NIX;
  579.   Feld_Intern [Y_MAX*X_MAX+4]=0;
  580.   Feld_Visible[Y_MAX*X_MAX+4]=HIDE;
  581.   Feld_Backup [Y_MAX*X_MAX+4]=NIX;
  582.  
  583. for  (y=0;y<=Y_MAX;y++)
  584. {
  585.  Feld_Visible[y*X_MAX]=SHOW;
  586.  Feld_Visible[y*X_MAX+X_MAX]=SHOW;
  587. }
  588. for  (x=0;x<=X_MAX;x++)
  589. { 
  590.  Feld_Visible[x]=SHOW;
  591.  Feld_Visible[Y_MAX*X_MAX+x]=SHOW;
  592. }
  593.  
  594.  
  595. /* Verteilung der Bomben */
  596. srand(time(NULL));           /* init der Random-zahlen */
  597.  
  598. for (t=1;t!=BOMB_MAX;t++)
  599. {
  600.  zufall_x=1+(rand() % (X_MAX-1));
  601.  zufall_y=1+(rand() % (Y_MAX-1));
  602.  Feld_Intern[zufall_x+zufall_y*X_MAX]=BOMB;  
  603. }
  604.  
  605.  
  606. /* Durchzaehlung , wo die Bomben liegen */
  607.  
  608. for (y=1;y<Y_MAX;y++)    
  609. {                         
  610.  for (x=1;x<=X_MAX;x++)   
  611.  {                        
  612.   if (BOMB!=Feld_Intern[x+y*X_MAX])
  613.   {
  614.    t=0;
  615.    if (BOMB==Feld_Intern[x-1+(y-1)*X_MAX]) t++;      /* element oben links   */
  616.    if (BOMB==Feld_Intern[x-1+(y  )*X_MAX]) t++;      /* element links        */
  617.    if (BOMB==Feld_Intern[x-1+(y+1)*X_MAX]) t++;      /* element unten links  */
  618.    if (BOMB==Feld_Intern[x+1+(y-1)*X_MAX]) t++;      /* element oben rechts  */ 
  619.    if (BOMB==Feld_Intern[x+1+(y  )*X_MAX]) t++;      /* element rechts       */
  620.    if (BOMB==Feld_Intern[x+1+(y+1)*X_MAX]) t++;      /* element rechts unten */
  621.    if (BOMB==Feld_Intern[x  +(y+1)*X_MAX]) t++;      /* element unten        */
  622.    if (BOMB==Feld_Intern[x  +(y-1)*X_MAX]) t++;      /* element oben         */
  623.    Feld_Intern[x+y*X_MAX]=t;  
  624.   }                        
  625.  }          
  626. }
  627.  
  628. }
  629.  
  630. void E()
  631. {
  632. printf("\n Parameters are: -Server -Client -Name.... -PortNumber.... -ServerName.... -NoNet\n");
  633. printf("\n (1) if you are the server :  -Server -PortNumber..... -Name..... ");
  634. printf("\n (2) if you are the client :  -Client -PortNumber..... -ServerName..... -Name..... ");
  635. printf("\n     Server-Programm MUST be running !");
  636. printf("\n (3) for a single user game:  -NoNet -Name.... \n");
  637. printf("\n .... stands for a string\n\n\n"); 
  638. printf("\n(C) by Martin Bauer\nif you want to contact me write a email to:");
  639. printf("\nInternet-Adress: Martin_Bauer@S2.MAUS.DE\n\n");
  640. fflush(stdout); exit(-1);
  641. }
  642.  
  643.  
  644. void check_command(argc,argv)
  645. int argc;
  646. char *argv[];
  647. {
  648. Server=1;
  649. Client=1;
  650. strcpy(Port,"");
  651. strcpy(ServerName,"");
  652. strcpy(User,"");
  653. if (argc>1)
  654. {
  655.  for (t=0;t<(argc-1);t++)
  656.  {
  657.   if (strcmp("-Server",argv[t+1])==0) 
  658.   {
  659.     Server=1;
  660.     Client=0;
  661.   }
  662.    if (strcmp("-Client",argv[t+1])==0)
  663.   {
  664.    Server=0;
  665.    Client=1;
  666.   }
  667.   if (strcmp("-NoNet",argv[t+1])==0)
  668.   {
  669.    Server=0;
  670.    Client=0; 
  671.   }
  672.   if (strncmp("-PortNumber",argv[t+1],11)==0)
  673.   { char text[500];
  674.     strcpy(text,argv[t+1]);
  675.     strcpy(Port,&text[11]);
  676.   }
  677.   if (strncmp("-Name",argv[t+1],5)==0)
  678.   {
  679.     char text[500];
  680.     strcpy(text,argv[t+1]);
  681.     strcpy(User,&text[5]);
  682. }
  683.   if (strncmp("-ServerName",argv[t+1],11)==0)
  684.   {
  685.     char text[500];
  686.     strcpy(text,argv[t+1]);
  687.     strcpy(ServerName,&text[11]);
  688.   }
  689.  }
  690. } else { printf("\n ERROR - not enough paramters\n\n"); fflush(stdout); E(); }
  691. if ((Client==1) && (Server==1)) { printf("\n ERROR   -Client or -Server flag is missing ! \n\n"); E(); }
  692. if ((Client==0) && (Server==0)) { if (strcmp(User,"")==0) {printf("\n ERROR - UserName is missing ! \n\n"); E(); } }
  693. printf("\n Server:%d  Client:%d  PortNum:%s \n",Server,Client,Port);
  694. printf(" Name:\"%s\"  ServerName:\"%s\"\n",User,ServerName);fflush(stdout);
  695. }
  696.  
  697. void CheckForClientEvent();
  698.  
  699. void sigi()
  700. {
  701.  signal(SIGPIPE,sigi);
  702.  
  703. }
  704.  
  705. main(argc,argv)
  706. int argc;
  707. char *argv[];
  708. {   char into[600];
  709.     next=NULL;
  710.     strcpy(winner,"it's not a sony, it's freeware  :=)");
  711.     weiter_msg=0;  
  712.     strcpy(msg[0],"May your children and mine live in peace");
  713.     strcpy(msg[1],"This is not a fault, this is a feature !");
  714.     strcpy(msg[2],"If you are female... write me ... soon !");
  715.     strcpy(msg[3],"Dont hit any mines !");
  716.     strcpy(msg[4],"Please write me if you enjoy this game");
  717.     signal(SIGPIPE,sigi);
  718.  
  719.    highest_kanal_number=20;
  720.  
  721.     check_command(argc,argv);
  722.     spielfeld_init();
  723.  
  724.     if(!(display = XOpenDisplay(Display_name)))
  725.     {
  726.         printf("Error: can't open display\n");
  727.         exit(1);
  728.     }
  729.  
  730.  
  731.     screen = DefaultScreen(display);
  732.     depth  = DefaultDepth(display,screen) ; 
  733.     cmap = DefaultColormap(display,screen); 
  734.     background = WhitePixel(display,screen);
  735.     foreground = BlackPixel(display,screen);
  736.     bg = getcolor("gray",background); 
  737.  
  738.     hint.x = 0; hint.y = 0;
  739.     hint.width = 622;
  740.     hint.height = 400;
  741.     hint.flags = PPosition | PSize;
  742.     window = XCreateSimpleWindow (display,
  743.                 DefaultRootWindow(display),
  744.                 hint.x, hint.y, hint.width, hint.height,
  745.                 5, foreground, background);
  746.     sprintf(into,"XNetMines  [%s]",User);  
  747.     XSetStandardProperties(display, window,into, into,
  748.         None, argv, argc, &hint);
  749.   
  750.     gc = XCreateGC(display, window, 0, 0);
  751.     XSetBackground(display, gc, background);
  752.     XSetForeground(display, gc, foreground);
  753.     highlightgc = XCreateGC(display, window, 0, 0);
  754.  
  755.      XSelectInput(display, window,
  756.         Button1MotionMask | Button2MotionMask | Button3MotionMask |
  757.          ButtonPressMask | ButtonReleaseMask |
  758.         KeyPressMask | ExposureMask);
  759.  
  760.  
  761.  
  762.     if((xfontinfo = XLoadQueryFont(display,fontname)) == NULL)
  763.     {
  764.         fprintf(stderr,"Can't find font '%s'\n",fontname);
  765.         xfontinfo = XQueryFont(display,XGContextFromGC(gc));
  766.     }
  767.     XSetFont(display,gc,xfontinfo->fid);
  768.  
  769.     b1=getcolor("blue",foreground);
  770.     b2=getcolor("green",foreground);
  771.     b3=getcolor("red",foreground);
  772.     b4=getcolor("orange",foreground);
  773.     b5=getcolor("violett",foreground);
  774.     b6=getcolor("cyan",foreground);
  775.     b7=getcolor("white",foreground);
  776.     b8=getcolor("magenta",foreground);
  777.     black=getcolor("black",foreground);
  778.     gray =getcolor("gray",foreground);
  779.     white=getcolor("white",foreground);
  780.  
  781.  
  782.     smileypix = XCreatePixmapFromBitmapData(display,window,
  783.                      smiley_bits,SWIDTH,SHEIGHT,foreground,
  784.                      background, depth);
  785.  
  786.     graypix = XCreatePixmapFromBitmapData(display,window,
  787.                     gray_bits,SWIDTH,SHEIGHT,foreground,
  788.                     background, depth);
  789.  
  790.     coveredpix = XCreatePixmapFromBitmapData(display,window,
  791.                     covered_bits,SWIDTH,SHEIGHT,foreground,
  792.                     background, depth);     
  793.  
  794.    lockpix = XCreatePixmapFromBitmapData(display,window,
  795.                     lock_bits,SWIDTH,SHEIGHT,foreground,
  796.                     background, depth);
  797.  
  798.   
  799.     minepix = XCreatePixmapFromBitmapData(display,window,
  800.                 mine_bits,SWIDTH,SHEIGHT,foreground,
  801.                 background, depth);
  802.  
  803.    netpix = XCreatePixmapFromBitmapData(display,window,
  804.                 net_bits,60,40,b1,
  805.                 background, depth);
  806.  
  807.    copyrightpix = XCreatePixmapFromBitmapData(display,window,
  808.                 copyright_bits,60,40,b1,
  809.                 background, depth);
  810.  
  811.    newpix = XCreatePixmapFromBitmapData(display,window,
  812.                 new_bits,60,40,b1,
  813.                 background, depth);
  814.     HighScore=0;
  815.     if(depth == 1)    
  816.     {
  817.         XSetWindowBackgroundPixmap(display,window,graypix);
  818.     }
  819.      
  820.     minepix_a = XCreatePixmapFromBitmapData(display,window,
  821.                 mine_bits,SWIDTH,SHEIGHT,foreground,
  822.                 b3, depth);
  823.  
  824.  
  825.     XMapRaised(display, window);
  826.     XFlush(display);
  827.     draw_screen();
  828.  
  829.     if ((Server==0) && (Client==0)) { CheckforEvent(); }
  830.  
  831. if (Server==1)
  832. { long PortNumber;
  833.  if (strcmp(Port,"")==0)       {printf("\n ERROR - PortNumber is missing ! \n\n"); E(); }
  834.  if (strcmp(User,"")==0)       {printf("\n ERROR - UserName   is missing ! \n\n"); E(); }
  835.  if (0==sscanf(Port,"%ld",&PortNumber)) { printf("\n ERROR - PortNumber is wrong ! \n\n"); E(); } 
  836.  sock_server=establish(PortNumber);
  837.  get_connection(sock_server);     /* und endlosschleife */
  838.  }
  839.  
  840. if (Client==1)
  841. { long PortNumber;
  842.     fd_set readfds;
  843.     struct timeval timeout;
  844.  if (strcmp(ServerName,"")==0) {printf("\n ERROR - ServerName is missing ! \n\n"); E(); }
  845.  if (strcmp(Port,"")==0)       {printf("\n ERROR - PortNumber is missing ! \n\n"); E(); }
  846.  if (strcmp(User,"")==0)       {printf("\n ERROR - UserName   is missing ! \n\n"); E(); }
  847.  if (0==sscanf(Port,"%ld",&PortNumber)) { printf("\n ERROR - PortNumber is wrong ! \n\n"); E(); }
  848.  s1=call_socket(ServerName,PortNumber);
  849.  if (s1==-1)
  850.  {
  851.    printf("\nError: Socketerror\n"); E();  
  852.  }
  853.  
  854.  {
  855.   long max,t;
  856.   struct AnfragePaket Anfrage;
  857.   strcpy( Anfrage.UserName,User);
  858.   max=X_MAX*Y_MAX;
  859.   for (t=0;t<=max;t++)
  860.     {
  861.       Anfrage.Feld_Visible[t]=Feld_Visible[t];
  862.       Anfrage.Feld_Intern[t] =Feld_Intern[t];
  863.     }
  864.   Anfrage.Was='W';                     /* s1 ist der kanal ZUM SCHREIBEN */
  865. timeout.tv_sec=10;
  866. timeout.tv_usec=0;
  867. FD_ZERO(&readfds);
  868. FD_SET(s1,&readfds);
  869. if (1==select(s1+1,0,&readfds,0,&timeout))
  870.     { 
  871.     write(s1,&Anfrage,sizeof(struct AnfragePaket));
  872.     }
  873.     else
  874.     {
  875.     printf("Error: Server-Timeout V1.0\n");
  876.     exit(-1);
  877.     }
  878.  
  879.   Anfrage.Was='R';                     /* s2 ist der kanal zum LESEN */
  880.   s2=call_socket(ServerName,PortNumber);
  881. timeout.tv_sec=10;
  882. timeout.tv_usec=0;
  883. FD_ZERO(&readfds);
  884.  if (s2==-1) {printf("\nError: Socketerror\n"); E(); }
  885. FD_SET(s2,&readfds);
  886. if (1==select(s2+1,0,&readfds,0,&timeout))
  887.     {
  888.   write(s2,&Anfrage,sizeof(struct AnfragePaket));
  889.      } 
  890.     else
  891.     {
  892.     printf("Error: Server-Timeout V2.0\n");
  893.     exit(-1);
  894.     }
  895.  CheckForClientEvent();  
  896.  }
  897. }
  898. }
  899.  
  900. void show_end()
  901. {
  902.   int xx,yy,nr,x,y;
  903.  
  904.   for (y=1;(y<Y_MAX-1);y++)
  905.   {                    
  906.    for (x=1;x<X_MAX;x++)   
  907.    {
  908.  
  909.   xx=x*bigx;
  910.   yy=y*bigy;
  911.   nr=x+y*X_MAX;
  912.  
  913.   if ((Feld_Intern[nr]==BOMB))
  914.    {
  915.      XCopyArea(display,minepix,window,gc,0,0,SWIDTH,SHEIGHT,xx-10,40+yy);
  916.    }
  917.  
  918.    if ((Feld_Visible[nr]==SHOW) && (Feld_Intern[nr]==EXBOMB))
  919.    {
  920.      XCopyArea(display,minepix_a,window,gc,0,0,SWIDTH,SHEIGHT,xx-10,40+yy);
  921.    }
  922.  
  923.   if ((Feld_Visible[nr]==LOCK) && (Feld_Intern[nr]!=BOMB))
  924.    { 
  925.      XSetForeground(display, gc, b3);
  926.      XDrawLine(display,window,gc,xx-10+bigx-3,40+yy,xx-10-3,40+yy+bigy);
  927.      XDrawLine(display,window,gc,xx-10,40+yy,xx-10+bigx,40+yy+bigy);
  928.    }
  929. }
  930. }
  931.   male_gitter();
  932. }
  933.  
  934. void CheckForClientEvent()
  935. { int max,res,x,y,xx,yy,size,i,err,change;    
  936.   fd_set readfds;
  937.   struct timeval timeout;
  938.   struct AnfragePaket Anfrage;
  939.  
  940.   for (;1==1;)
  941.   {
  942.    FD_ZERO(&readfds);
  943.    FD_SET(s2,&readfds );
  944.    timeout.tv_sec=0; 
  945.    timeout.tv_usec=800;
  946.    res = select(s2+1, &readfds, 0, 0, &timeout);
  947.    if ((res!=-1) && (FD_ISSET(s2,&readfds))) 
  948.    { /* aha, server schickt uns daten */
  949.      err=reads(s2,&Anfrage,sizeof(struct AnfragePaket));
  950.      if (err!=sizeof(struct AnfragePaket)) {  printf("\n Socket-Datenfehler \n"); exit(-1);}
  951.      max=X_MAX*Y_MAX;
  952.      if ((Anfrage.Feld_Visible[Y_MAX*X_MAX+3]==77) && (Feld_Visible[Y_MAX*X_MAX+3]!=77))
  953.      {  spiel_laeuft=0;
  954.          /* anderer Player hat gewonnen */
  955.         other_player_win(0);
  956.      }
  957.      
  958.      if (Anfrage.Feld_Intern[Y_MAX*X_MAX+4]==99) 
  959.      {
  960.       weiter_msg++;
  961.       if (weiter_msg>max_msg) weiter_msg=0;  
  962.       strcpy(winner,msg[weiter_msg]);
  963.   
  964.       spiel_laeuft=1;HighScore=0;
  965.       for (t=0;t<=(max+4);t++)
  966.       { 
  967.         Feld_Visible[t]=HIDE;
  968.         Feld_Intern[t]=0;
  969.        }
  970.        draw_screen(); 
  971.      }
  972.     for (t=0;t<=max;t++)
  973.      {
  974.      if (spiel_laeuft==1)
  975.      {
  976.       if ((SHOW==Anfrage.Feld_Visible[t])&&(Feld_Intern[t]!=BOMB)) Feld_Visible[t]=SHOW;
  977.       if (Feld_Intern[t]!=EXBOMB) Feld_Intern[t]=Anfrage.Feld_Intern[t];
  978.      }
  979.        }
  980.           for (y=1;(y<Y_MAX);y++)
  981.           {
  982.             for (x=1;x<X_MAX;x++)
  983.             {
  984.             
  985.              if (Feld_Visible[x+y*X_MAX]!=Feld_Backup[x+y*X_MAX])
  986.               {
  987.                draw_item(x,y);
  988.               }
  989.             }
  990.           }
  991.           male_gitter();
  992.        }
  993.   if (XPending(display))      
  994.   {
  995.    getXevent();    /* bearbeite event */
  996.   }
  997.  }
  998. }
  999.  
  1000. CheckforEvent()
  1001. {   
  1002.  for (;1==1;)
  1003.  {    
  1004.  /*  if (XPending(display))          => nur wenn wir noch was machen wollen */
  1005.   {                                       
  1006.    getXevent();                      
  1007.   }
  1008.  }
  1009. }
  1010.  
  1011. void draw_item(x,y)
  1012. int x,y;
  1013. {
  1014.   char a;
  1015.   int xx,yy,nr;
  1016.   a='.';
  1017.   xx=x*bigx;
  1018.   yy=y*bigy;
  1019.   nr=x+y*X_MAX;
  1020.   XSetForeground(display, gc, gray);
  1021.   XFillRectangle(display,window,gc,xx-10,40+yy,20,20); 
  1022.   Feld_Backup[nr]=Feld_Visible[nr];
  1023.   if (Feld_Visible[nr]==SHOW)
  1024.   {
  1025.    if (Feld_Intern[nr]==0)    { a='.'; }
  1026.    if (Feld_Intern[nr]==1)    { a='1'; XSetForeground(display, gc, b1); }
  1027.    if (Feld_Intern[nr]==2)    { a='2'; XSetForeground(display, gc, b2); }
  1028.    if (Feld_Intern[nr]==3)    { a='3'; XSetForeground(display, gc, b3); }
  1029.    if (Feld_Intern[nr]==4)    { a='4'; XSetForeground(display, gc, b4); }
  1030.    if (Feld_Intern[nr]==5)    { a='5'; XSetForeground(display, gc, b5); }
  1031.    if (Feld_Intern[nr]==6)    { a='6'; XSetForeground(display, gc, b6); }
  1032.    if (Feld_Intern[nr]==7)    { a='7'; XSetForeground(display, gc, b7); }
  1033.    if (Feld_Intern[nr]==8)    { a='8'; XSetForeground(display, gc, b8); }
  1034.    if (Feld_Intern[nr]==EXBOMB) 
  1035.    { a='.';  
  1036.     XCopyArea(display,minepix_a,window,gc,0,0,SWIDTH,SHEIGHT,xx-10,40+yy);
  1037.    }
  1038.  
  1039.   if (Feld_Intern[nr]==BOMB)
  1040.    {
  1041.        XCopyArea(display,minepix,window,gc,0,0,SWIDTH,SHEIGHT,xx-10,40+yy);
  1042.        a='.';  
  1043.    }
  1044.    if (a!='.')
  1045.    { char text[4];
  1046.      text[0]=a; text[1]=0;
  1047.      XDrawString(display,window,gc,xx-4,54+yy,text,1);
  1048.    }
  1049.   }
  1050.   if (Feld_Visible[nr]==HIDE)
  1051.   { 
  1052.      xx=x*bigx-8;
  1053.      yy=y*bigy+42;
  1054.      XSetForeground(display, gc, white);
  1055.      XFillRectangle(display,window,gc,xx-2,yy-2,20,20);
  1056.      XSetForeground(display, gc, gray);
  1057.      XFillRectangle(display,window,gc,xx,yy,18,18);
  1058.   }
  1059.  
  1060.  if (Feld_Visible[nr]==LOCK)
  1061.   { 
  1062.    XCopyArea(display,lockpix,window,gc,0,0,SWIDTH,SHEIGHT,x*bigx-10,39+y*bigy);
  1063.   }
  1064. }
  1065.  
  1066. void male_gitter()
  1067. {
  1068.    int i,x,y,xx,yy;
  1069.    XSetForeground(display, gc, black);
  1070.    for (i=0;i<2;i++)
  1071.    {
  1072.     for (y=0;y<(Y_MAX);y++)     
  1073.     {
  1074.      yy=y*bigy;
  1075.      XDrawLine(display,window,gc,bigx-12,yy+58+i,X_MAX*bigx-bigx+9,58+yy+i);
  1076.     }
  1077.     for (x=0;x<(X_MAX);x++)
  1078.     {
  1079.      xx=x*bigx;
  1080.      XDrawLine(display,window,gc,i+xx+8,60,i+xx+8,38+Y_MAX*bigy);
  1081.     }
  1082.    }
  1083. }
  1084.  
  1085.  
  1086. void draw_screen()
  1087. { 
  1088.   long dir,xx,yy,x,y,a,b,c,d;
  1089.   GC highlightgc,shadowgc;
  1090.  
  1091.   XSetForeground(display, gc, white);
  1092.   XFillRectangle(display,window,gc,9,60,bigx*X_MAX-bigx,bigy*Y_MAX);
  1093.   XSetBackground(display, gc, gray);
  1094.   XSetForeground(display, gc, gray);
  1095.   XFillRectangle(display,window,gc,0,0,1280,59);
  1096.   XFillRectangle(display,window,gc,0,0,9,1000);
  1097.   XFillRectangle(display,window,gc,8+(X_MAX-1)*bigx,0,800,1000);
  1098.   XFillRectangle(display,window,gc,0,60+(Y_MAX-1)*bigy,800,1000);
  1099.   XSetForeground(display, gc, gray);
  1100.   for (y=1;y<Y_MAX;y++)
  1101.   {
  1102.    for (x=1;x<X_MAX;x++)
  1103.    {
  1104.      xx=x*bigx-8;
  1105.      yy=y*bigy+42;
  1106.      XFillRectangle(display,window,gc,xx,yy,18,18);
  1107.   }
  1108.   }
  1109.   for (y=1;(y<Y_MAX);y++)
  1110.   {                    
  1111.    for (x=1;x<X_MAX;x++)   
  1112.    {
  1113.     if (Feld_Visible[x+y*X_MAX]!=HIDE)
  1114.     {
  1115.      draw_item(x,y);
  1116.     }
  1117.    }
  1118.   }
  1119.   XSetForeground(display, gc, black);
  1120.   XCopyArea(display,copyrightpix,window,gc,0,0,60,40,10,10);
  1121.   XCopyArea(display,netpix,window,gc,0,0,60,40,550,10);
  1122.   if (Client!=1) XCopyArea(display,newpix,window,gc,0,0,60,40,270,10);
  1123.   male_gitter();
  1124.   if (spiel_laeuft==0) show_end();
  1125.     sprintf(text,"Score: %d",HighScore);
  1126.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1127.                        XFillRectangle(display,window,gc,75,0,60,50);
  1128.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1129.                        XDrawString(display,window,gc,75,30 ,text,strlen(text));
  1130.                   
  1131.  
  1132.                 XSetForeground(display, gc, getcolor("gray",foreground));
  1133.                        XFillRectangle(display,window,gc,4,383,625,400);
  1134.                        XSetForeground(display, gc, getcolor("red",foreground));
  1135.                     XDrawString(display,window,gc,10,395,winner,strlen(winner));
  1136.        
  1137.  
  1138. }
  1139.  
  1140.  
  1141. void Fuelle(x,y)
  1142. int x,y;
  1143. {
  1144. xx=x+y*X_MAX;
  1145. Feld_Visible[xx]=SHOW;
  1146. draw_item(x,y);
  1147. if (Feld_Intern[xx]==0)
  1148.  { 
  1149.    if (Feld_Visible[x+y*X_MAX+1    ]==HIDE) Fuelle(x+1,y);
  1150.    if (Feld_Visible[x+y*X_MAX-1    ]==HIDE) Fuelle(x-1,y);
  1151.    if (Feld_Visible[x+y*X_MAX+X_MAX]==HIDE) Fuelle(x,y+1);
  1152.    if (Feld_Visible[x+y*X_MAX-X_MAX]==HIDE) Fuelle(x,y-1);
  1153.  }
  1154. }
  1155.  
  1156. Client_to_Server()
  1157. {   struct AnfragePaket Anfrage;
  1158.                        Anfrage.Was='W'; 
  1159.                        strcpy( Anfrage.UserName,User);
  1160.                        max=X_MAX*Y_MAX+4;
  1161.                        for (t=0;t<=max;t++)
  1162.                        {
  1163.                          Anfrage.Feld_Visible[t]=Feld_Visible[t];
  1164.                          Anfrage.Feld_Intern[t]=Feld_Intern[t];
  1165.                        }
  1166.     err=write(s1,&Anfrage,sizeof(struct AnfragePaket));
  1167.     if (err!=sizeof(struct AnfragePaket)) { printf("\n socket-write fehler \n"); exit(-1); }
  1168. }                    
  1169.  
  1170. getXevent()                                 
  1171. {
  1172.     XNextEvent(display, &event);
  1173.     switch(event.type)
  1174.     {
  1175.         case Expose:
  1176.             if(event.xexpose.window == window)
  1177.             {
  1178.                 if(event.xexpose.count == 0)
  1179.                 {
  1180.                     /* window wurde gemoved , also neu aufbauen */
  1181.                     draw_screen();
  1182.                 }
  1183.             }
  1184.             break;                          
  1185.         case ButtonPress:                      
  1186.             if(event.xkey.window == window)
  1187.             {
  1188.                 x = (event.xbutton.x-XOFFSET)/SWIDTH;
  1189.                 y = (event.xbutton.y-YOFFSET)/SHEIGHT;
  1190.                 xx=event.xbutton.x;
  1191.                 yy=event.xbutton.y;
  1192.                 if ((yy>=10) && (yy<=40))
  1193.                 {
  1194.                   if ((xx>10) && (xx<70))
  1195.                   { /* Copyright angeklickt */
  1196.                        char text[120];
  1197.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1198.                        XFillRectangle(display,window,gc,4,383,625,400);
  1199.                        XSetForeground(display, gc, getcolor("red",foreground));
  1200.                        strcpy(text,"(c) 1994 by Martin Bauer    to contact me: Martin_Bauer@S2.MAUS.DE");
  1201.                        strcpy(winner,text);   
  1202.                     XDrawString(display,window,gc,10,395,text,strlen(text));
  1203.                   }
  1204.                  
  1205.                   if ((xx>270) && (xx<330) && (Client!=1))
  1206.                   { /* new angeklickt */
  1207.  
  1208.                     spielfeld_init();
  1209.                     weiter_msg++;
  1210.                      if (weiter_msg>max_msg) weiter_msg=0;  
  1211.   
  1212.                     strcpy(winner,msg[weiter_msg]);
  1213.  
  1214.                     HighScore=0;
  1215.                     draw_screen(); 
  1216.                     Feld_Intern[Y_MAX*X_MAX+4]=99;
  1217.                     Sende_to_Client();           
  1218.                     Feld_Intern[Y_MAX*X_MAX+4]=0;
  1219.                  }
  1220.  
  1221.                   if ((xx>550) && (xx<610))
  1222.                   { /* net-config angeklickt */
  1223.                     if (Server==1) close(sock_server);
  1224.                     if (Client==1) close(s1);
  1225.                     if (Client==1) close(s2);
  1226.                     exit(-1);
  1227.                   }
  1228.                 } 
  1229.                if ((x>=0) && (x<(X_MAX-1)) && (y>=0) && (y<(Y_MAX-1)) && (spiel_laeuft==1))
  1230.                 {    /* spieler hat im Spielfeld geklickt ! */
  1231.                   x++; y++;
  1232.              if (event.xbutton.button==Button1)
  1233.              {    /* taste 1 im spielfeld geklickt ! */
  1234.                   xx=x+y*X_MAX; 
  1235.                   if (Feld_Visible[xx]==HIDE)
  1236.                   {  /* hat auf verstecktes feld getippt */
  1237.                      Feld_Visible[xx]=SHOW;
  1238.                      if (Feld_Intern[xx]==0)    { Fuelle(x,y); }
  1239.  
  1240.                      if ((Feld_Intern[xx]!=BOMB) && (Client==1))
  1241.                      {  /* ok, jetzt dem server mitteilen */
  1242.                        long max,t,err,size;
  1243.                        struct AnfragePaket Anfrage;
  1244.                        Anfrage.Was='W'; 
  1245.                        strcpy( Anfrage.UserName,User);
  1246.                        max=X_MAX*Y_MAX;
  1247.                        for (t=0;t<=max;t++)
  1248.                        {
  1249.                          Anfrage.Feld_Visible[t]=Feld_Visible[t];
  1250.                          Anfrage.Feld_Intern[t]=Feld_Intern[t];
  1251.                        }
  1252.                      err=write(s1,&Anfrage,sizeof(struct AnfragePaket));
  1253.                      if (err!=sizeof(struct AnfragePaket)) { printf("\n socket-write fehler \n"); exit(-1); }
  1254.                      }
  1255.                      if ((Feld_Intern[xx]!=BOMB) && (Server==1))
  1256.                      {  /* ok, jetzt den clients mitteilen */
  1257.                       Sende_to_Client();                       
  1258.                      }
  1259.                      if (Feld_Intern[xx]==BOMB) 
  1260.                      { char text[80];
  1261.                        spiel_laeuft=0;
  1262.                        Feld_Intern[xx]=EXBOMB;
  1263.                        strcpy(text,"Booooooommmmmm , you lost the game. Please restart the game now.");
  1264.                        if (Client==1) strcpy(text,"You lost the game. This game will be restart after one Player is left");
  1265.                        if (Server==1) strcpy(text,"You lost the game. Please DO NOT restart the Game NOW. ");
  1266.                        if ((Server==1) && (next==NULL))  strcpy(text,"You lost the game. Please RESTART the Game NOW. ");
  1267.  
  1268.                        strcpy(winner,text); 
  1269.                       XSetForeground(display, gc, getcolor("gray",foreground));
  1270.                        XFillRectangle(display,window,gc,4,385,625,400);
  1271.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1272.                        XDrawString(display,window,gc,10,395 ,text,strlen(text));
  1273.                        show_end(); 
  1274.                       }
  1275.                      if ((Feld_Intern[xx]!=BOMB))
  1276.                      {  /* user hat ein zahlenfeld/space aufgedeckt ! */
  1277.                        int k;
  1278.                        k=0;
  1279.                        if (Feld_Intern[xx]<=8) HighScore=HighScore+Feld_Intern[xx];
  1280.                        sprintf(text,"Score: %d",HighScore);
  1281.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1282.                        XFillRectangle(display,window,gc,75,0,80,55);
  1283.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1284.                        XDrawString(display,window,gc,75,30 ,text,strlen(text));
  1285.                        max=X_MAX*Y_MAX;
  1286.                        for (t=0;t<=max;t++)
  1287.                        {
  1288.                          if ((Feld_Visible[t]==HIDE)) k=1;
  1289.                          if ((Feld_Intern[t]!=BOMB) && (Feld_Visible[t]==LOCK)) k=1;
  1290.                        }
  1291.                        if (k==0) 
  1292.                        {/* spiel beendet und gewonnen ! */ 
  1293.                         spiel_laeuft=0;
  1294.                        strcpy(text,"You win the game. Please RESTART NOW the game ");
  1295.                        if (Client==1) strcpy(text,"You win the game. This game will be restart by the Serverplayer now");
  1296.                        if (Server==1) strcpy(text,"You win the game. Please RESTART NOW the game ");
  1297.                         strcpy(winner,text);
  1298.                        Feld_Visible[X_MAX*Y_MAX+3]=77;
  1299.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1300.                        XFillRectangle(display,window,gc,4,385,625,400);
  1301.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1302.                        XDrawString(display,window,gc,10,395 ,text,strlen(text));
  1303.                        if (Server==1) Sende_to_Client();
  1304.                        if (Client==1) 
  1305.                          {
  1306.                            Client_to_Server();                    
  1307.                          }    
  1308.  
  1309.                     }
  1310.  
  1311.                    }
  1312.  
  1313.  
  1314.                      draw_item(x,y);
  1315.                      male_gitter();
  1316.                   }
  1317.               } else
  1318.               { /* taste 2/3 im spielfeld geklickt ! */
  1319.                   xx=x+y*X_MAX;
  1320.                   
  1321.                   if (Feld_Visible[xx]==HIDE)
  1322.                   {
  1323.                    /* hat auf verstecktes feld getippt */
  1324.                    Feld_Visible[xx]=LOCK;
  1325.                    draw_item(x,y);
  1326.                    male_gitter();
  1327.                   } else
  1328.                   { 
  1329.                   if (Feld_Visible[xx]==LOCK)
  1330.                     {
  1331.                      /* hat auf gelocktes feld getippt */
  1332.                     Feld_Visible[xx]=HIDE;               
  1333.                     draw_item(x,y);
  1334.                     male_gitter();
  1335.                     } 
  1336.                   }
  1337.                      {  /* user hat ein zahlenfeld/space aufgedeckt ! */
  1338.                        int k;
  1339.                        k=0;
  1340.                        sprintf(text,"Score: %d",HighScore);
  1341.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1342.                        XFillRectangle(display,window,gc,75,0,80,55);
  1343.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1344.                        XDrawString(display,window,gc,75,30 ,text,strlen(text));
  1345.                        max=X_MAX*Y_MAX;
  1346.                       for (t=0;t<=max;t++)
  1347.                        {
  1348.                          if ((Feld_Visible[t]==HIDE)) k=1;
  1349.                          if ((Feld_Intern[t]!=BOMB) && (Feld_Visible[t]==LOCK)) k=1;
  1350.                        }
  1351.                        if (k==0) 
  1352.                        {/* spiel beendet und gewonnen ! */ 
  1353.                        spiel_laeuft=0;
  1354.                        strcpy(text,"You win the game.");
  1355.                        strcpy(text,"You win the game. Please RESTART NOW the game ");
  1356.                        if (Client==1) strcpy(text,"You win the game. This game will be restart by the Serverplayer now");
  1357.                        if (Server==1) strcpy(text,"You win the game. Please RESTART NOW the game ");
  1358.                        strcpy(winner,text);
  1359.                        Feld_Visible[X_MAX*Y_MAX+3]=77;
  1360.                        XSetForeground(display, gc, getcolor("gray",foreground));
  1361.                        XFillRectangle(display,window,gc,4,385,625,400);
  1362.                        XSetForeground(display, gc, getcolor("blue",foreground));
  1363.                        XDrawString(display,window,gc,10,395 ,text,strlen(text));
  1364.                        if (Server==1) Sende_to_Client();
  1365.                        if (Client==1) 
  1366.                          {
  1367.                           Client_to_Server();
  1368.                          }    
  1369.  
  1370.                         }
  1371.  
  1372.                    }
  1373.  
  1374.               }
  1375.                 }
  1376.             }
  1377.             break;
  1378.  
  1379.     }
  1380.  
  1381.  
  1382. }
  1383.  
  1384.